﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;

namespace Dominio
{
    public class Sistema
    {
        #region variables

        public static string phisicalPath;
        public static Sistema instance;
        private static IPersistencia persistencia;

        #endregion

        #region constructor

        public Sistema()
        {
            //        Me.mLArticulos = New ArrayList
            //        Me.mLClientes = New ArrayList
            //        Me.mLPlanDePago = New ArrayList
            //        Me.mLProveedores = New ArrayList
            //        Me.mLDocumentos = New ArrayList
            //        reflectionGetPersistence()
        }

        public static Sistema getInstance()
        {
            if (instance == null)
            {
                instance = new Sistema();
            }
            return instance;
        }

        #endregion        

        #region persistenceMethods

        public static void reflectionGetPersistence()
        {
            phisicalPath = System.IO.Directory.GetCurrentDirectory();
            string path = phisicalPath + "\\Persistencia.dll";
            Assembly a = Assembly.LoadFrom(path);
            Type[] myTypes = a.GetTypes();
            foreach (Type type in myTypes)
            {
                if (type.Name.Equals("FachadaPersistencia"))
                {
                    persistencia = (IPersistencia)Activator.CreateInstance(type);
                    persistencia.connectToDB();
                }
            }
        }

        public static IPersistencia getPersistencia()
        {
            if (persistencia == null)
            {
                reflectionGetPersistence();
            }
            return persistencia;
        }

        #endregion

        #region articulos

        public static void agregarArticulo(string unCodigo, string unaDescripcion,
            DateTime unaFechaIngreso, string unaImagen, IVA unIVA, string unNombre, PrecioArticulo precioVenta)
        {
            Articulo unArticulo = new Articulo();
            unArticulo.Codigo = unCodigo;
            unArticulo.Descripcion = unaDescripcion;
            unArticulo.FechaIngreso = unaFechaIngreso;
            unArticulo.Habilitado = true;
            unArticulo.Imagen = unaImagen;
            unArticulo.IVA = unIVA;
            unArticulo.Nombre = unNombre;
            unArticulo.PrecioVentaActual = precioVenta;
            unArticulo.added();
        }

        public static void eliminarArticulo(Articulo unArticulo)
        {            
            unArticulo.removed();
        }

        public static void modificarArticulo(string unCodigo, string unaDescripcion,
            DateTime unaFechaIngreso, string unaImagen, IVA unIVA, string unNombre,
            int unStock, bool esHabilitado, double unPrecioVenta, Articulo unArticulo)
        {
            unArticulo.Codigo = unCodigo;
            unArticulo.Descripcion = unaDescripcion;            
            unArticulo.FechaIngreso = unaFechaIngreso;
            unArticulo.Imagen = unaImagen;
            unArticulo.IVA = unIVA;
            unArticulo.Nombre = unNombre;
            unArticulo.Stock = unStock;
            unArticulo.Habilitado = esHabilitado;
            PrecioArticulo precioVenta = new PrecioArticulo();
            precioVenta.Precio = unPrecioVenta;
            unArticulo.PrecioVentaActual = precioVenta;
            unArticulo.updated();
        }

        public static List<Articulo> getArticulos()
        {
            Articulo articuloAux = new Articulo();
            List<Object> objectArticulos = getPersistencia().bringList(articuloAux);
            List<Articulo> articulos = new List<Articulo>();
            for (int i = 0; i < objectArticulos.Count; i++)
            {
                Articulo unArticulo = (Articulo)objectArticulos[i];
                articulos.Add(unArticulo);
            }
            return articulos;
        }

        public static int getUltimoIdArticulo()
        {
            int ultimoId = getPersistencia().bringLastOID(new Articulo());
            return ultimoId;
        }

        public static List<Articulo> buscarArticulos(int idDesde, int idHasta,
            string codigo, string nombre, int stockDesde, int stockHasta, int iva)
        {
            return getPersistencia().buscarArticulos(idDesde, idHasta, codigo,
                nombre, stockDesde, stockHasta, iva);
        }

        public static List<Articulo> traerArticulosNoHabilitados()
        {
            return getPersistencia().traerArticulosNoHabilitados();
        }

        ///////////////////////////////////////////////////////////

        //hacer por bd
        public static Articulo buscarArticuloPorId(string id)
        {
            return getPersistencia().buscarArticuloPorId(id);
        }        

        //hacer por bd
        public static List<Articulo> listarArticulosPorFecha(DateTime unaF)
        {
            return getPersistencia().listarArticulosPorFecha(unaF);
        }

        //hacer por bd
        public static List<Articulo> listarArticulosPorCodigo(string desde, string hasta)
        {
            return getPersistencia().listarArticulosPorCodigo(desde, hasta);
        }

        //hacer por bd
        public static List<Articulo> listarArticuloPorStock(int desde, int hasta)
        {
            return getPersistencia().listarArticuloPorStock(desde, hasta);
        }

        //hacer por bd o metodo
        public static int obtenerStockAFecha(DateTime unaF)
        {
            return 0;
        }

        

                
        //    'encuentra un artículo si el código es el mismo al parámetro
        //    Public Function buscarArticulo(ByVal id As String) As Articulo
        //        Dim unA As Articulo
        //        For Each unA In Me.LArticulos
        //            If unA.codigo = id Then
        //                Return unA
        //            End If
        //        Next
        //        Return New Articulo
        //    End Function

        //    'lista los artículos con el stock correspondiente a la fecha dada
        //    Public Function listarArticulosPorFecha(ByVal unaF As Date, ByVal unaL As ArrayList) As ArrayList
        //        Dim lNueva As New ArrayList
        //        For Each unA As Articulo In unaL
        //            Me.obtenerStockAFecha(unaF)
        //            lNueva.Add(unA)
        //        Next
        //        Return lNueva
        //    End Function
        //    'lista los artículos con un código que se encuentre entre los especificados
        //    Public Function listarArticulosPorCodigo(ByVal desde As String, ByVal hasta As String) As ArrayList
        //        Dim lNueva As New ArrayList
        //        For Each unA As Articulo In Me.LArticulos
        //            If (unA.codigo.CompareTo(desde) >= 0) And (unA.codigo.CompareTo(hasta) <= 0) Then
        //                lNueva.Add(unA)
        //            End If
        //        Next
        //        Return lNueva
        //    End Function
        //    'lista los artículos que tengan stock entre los parámetros
        //    Public Function listarArticulosPorStock(ByVal desde As Integer, ByVal hasta As Integer, ByVal unaL As ArrayList) As ArrayList
        //        Dim lNueva As New ArrayList
        //        For Each unA As Articulo In unaL
        //            If (unA.stockFlotante >= desde) And (unA.stockFlotante <= hasta) Then
        //                lNueva.Add(unA)
        //            End If
        //        Next
        //        Return lNueva
        //    End Function

        //    'obtiene el stock correspondiente de cada artículo a una fecha
        //    Public Function obtenerStockAFecha(ByVal unaF As Date) As Integer
        //        Dim unaFC As New FacturaCredito
        //        Dim unDCD As New DocConDetalles
        //        For Each unD As Documento In Me.LDocumento
        //            If unaF > unD.fecha Then
        //                If unD.GetType.Equals(unDCD.GetType) Then
        //                    If unD.GetType.Equals(unaFC.GetType) Then
        //                        For Each unDet As Detalle In CType(unD, NotaCredito).detalles
        //                            unDet.articulo.stockFlotante = unDet.articulo.stockFlotante - unDet.cantidad
        //                        Next
        //                    Else
        //                        For Each unDet As Detalle In CType(unD, DocConDetalles).detalles
        //                            unDet.articulo.stockFlotante = unDet.articulo.stockFlotante + unDet.cantidad
        //                        Next
        //                    End If
        //                End If
        //            End If
        //        Next
        //    End Function

        #endregion

        #region clientes

        public static void agregarCliente(string unaDireccion, string unEMail, int unFax,
            string unNombre, PlanDePago unPlanDePago, string unRUT)
        {
            Cliente unCliente = new Cliente();
            unCliente.Direccion = unaDireccion;
            unCliente.EMail = unEMail;
            unCliente.Fax = unFax;
            unCliente.Habilitado = true;
            unCliente.Nombre = unNombre;
            unCliente.PlanDePago = unPlanDePago;
            unCliente.RUT = unRUT;            
            unCliente.added();
        }

        public static void eliminarCliente(Cliente unCliente)
        {            
            unCliente.removed();
        }

        public static void modificarCliente(string unaDireccion, string unEMail, int unFax,
            string unNombre, PlanDePago unPlanDePago, string unRUT, bool esHabilitado, Cliente unCliente)
        {
            unCliente.Direccion = unaDireccion;
            unCliente.EMail = unEMail;
            unCliente.Fax = unFax;
            unCliente.Nombre = unNombre;
            unCliente.PlanDePago = unPlanDePago;
            unCliente.RUT = unRUT;
            unCliente.Habilitado = esHabilitado;
            unCliente.updated();
        }

        public static List<Cliente> getClientes()
        {
            Cliente clienteAux = new Cliente();
            List<object> objectClientes = getPersistencia().bringList(clienteAux);
            List<Cliente> clientes = new List<Cliente>();
            for (int i = 0; i < objectClientes.Count; i++)
            {
                Cliente unCliente = (Cliente)objectClientes[i];
                clientes.Add(unCliente);
            }
            return clientes;
        }

        public static int getUltimoIdCliente()
        {
            int ultimoId = getPersistencia().bringLastOID(new Cliente());
            return ultimoId;
        }

        public static List<Cliente> buscarClientes(string nombre, double saldoDesde, double saldoHasta,
            string rut, int numeroDesde, int numeroHasta, int idPlanDePago, string unaDireccion)
        {
            return getPersistencia().buscarClientes(nombre, saldoDesde, saldoHasta, rut,
                numeroDesde, numeroHasta, idPlanDePago, unaDireccion);
        }

        public static List<Cliente> traerClientesNoHabilitados()
        {
            return getPersistencia().traerClientesNoHabilitados();
        }

        //public static Cliente buscarClientePorId(int id)
        //{
        //    return getPersistencia().buscarClientePorId(id);
        //}

        //public static List<Cliente> listarClientesPorNumero(int desde, int hasta)
        //{
        //    return getPersistencia().listarClientesPorNumero(desde, hasta);
        //}

        //public static List<Cliente> listarClientesPorNombre(string desde, string hasta)
        //{
        //    return getPersistencia().listarClientesPorNombre(desde, hasta);
        //}

        ////ver metodo obtenerSaldoAFecha y si no es viable cambiar a consultabd
        //public static List<Cliente> listarClientesPorFecha(DateTime unaF, List<Cliente> clientes)
        //{
        //    List<Cliente> clientesPorFecha = new List<Cliente>();
        //    foreach (Cliente unC in clientes)
        //    {
        //        unC.obtenerSaldoAFecha(unaF);
        //        clientesPorFecha.Add(unC);
        //    }
        //    return clientesPorFecha;
        //}

        #endregion

        #region documentos

        //cambiar a consultaBD
        public static List<Documento> listarDocumentosPorFechas(DateTime desde, DateTime hasta, Type unT)
        {
            return null;
        }

        #endregion

        #region facturasCredito

        public static void agregarFacturaCredito(Cliente unCliente, List<Detalle> unaLDetalles, DateTime unaFecha, double unMonto)
        {
            FacturaCredito unaFactCred = new FacturaCredito();
            unaFactCred.Cliente = unCliente;
            unaFactCred.Detalles = unaLDetalles;
            unaFactCred.Fecha = unaFecha;
            unaFactCred.Monto = unMonto;
            unaFactCred.Vencimiento = unaFecha.AddDays(unCliente.PlanDePago.CantDias);            
            unaFactCred.added();
        }

        public static void modificarFacturaCredito(Cliente unCliente, List<Detalle> unaLDetalles,
            DateTime unaFecha, double unMonto, double unSaldo, FacturaCredito unaFactCred)
        {
            unaFactCred.Cliente = unCliente;
            unaFactCred.Detalles = unaLDetalles;
            unaFactCred.Fecha = unaFecha;
            unaFactCred.Monto = unMonto;
            unaFactCred.Saldo = unSaldo;
            unaFactCred.Vencimiento = unaFactCred.Fecha.AddDays(unCliente.PlanDePago.CantDias);
            unaFactCred.updated();
        }

        public static List<FacturaCredito> getFacturasCredito()
        {
            FacturaCredito facturaAux = new FacturaCredito();
            List<object> objectFacturas = getPersistencia().bringList(facturaAux);
            List<FacturaCredito> facturas = new List<FacturaCredito>();
            for (int i = 0; i < objectFacturas.Count; i++)
            {
                FacturaCredito unaFactura = (FacturaCredito)objectFacturas[i];
                facturas.Add(unaFactura);
            }
            return facturas;
        }

        public static int getUltimoIdFacturaCredito()
        {
            int ultimoId = getPersistencia().bringLastOID(new FacturaCredito());
            return ultimoId;
        }

        //hacer metodos con bd
        public static FacturaCredito buscarFacturaCreditoPorId(int id)
        {
            return getPersistencia().buscarFacturaCreditoPorId(id);
        }

        //hacer metodo con bd
        private static List<FacturaCredito> listarFacturasPorVencimiento(DateTime desde, DateTime hasta)
        {
            return getPersistencia().listarFacturasPorVencimiento(desde, hasta);
        }

        #endregion

        #region facturasProveedor

        public static void agregarFacturaProveedor(List<Detalle> unaLDetalles, DateTime unaFecha,
            double unMonto, int unNumerador, Proveedor unProveedor)
        {
            FacturaProveedor unaFactProv = new FacturaProveedor();
            unaFactProv.Detalles = unaLDetalles;
            unaFactProv.Fecha = unaFecha;
            unaFactProv.Monto = unMonto;
            unaFactProv.Numerador = unNumerador;
            unaFactProv.Proveedor = unProveedor;
            unaFactProv.Vencimiento = unaFactProv.Fecha.AddDays(unProveedor.PlanDePago.CantDias);            
            unaFactProv.added();
        }

        public static void modificarFacturaProveedor(List<Detalle> unaLDetalles, DateTime unaFecha,
            double unMonto, int unNumerador, Proveedor unProveedor, double unSaldo, FacturaProveedor unaFactProv)
        {
            unaFactProv.Detalles = unaLDetalles;
            unaFactProv.Fecha = unaFecha;
            unaFactProv.Monto = unMonto;
            unaFactProv.Numerador = unNumerador;
            unaFactProv.Proveedor = unProveedor;
            unaFactProv.Vencimiento = unaFactProv.Fecha.AddDays(unProveedor.PlanDePago.CantDias);
            unaFactProv.Saldo = unSaldo;
            unaFactProv.updated();
        }

        public static List<FacturaProveedor> getFacturasProveedor()
        {
            FacturaProveedor facturaAux = new FacturaProveedor();
            List<object> objectFacturas = getPersistencia().bringList(facturaAux);
            List<FacturaProveedor> facturas = new List<FacturaProveedor>();
            for (int i = 0; i < objectFacturas.Count; i++)
            {
                FacturaProveedor unaFactura = (FacturaProveedor)objectFacturas[i];
                facturas.Add(unaFactura);
            }
            return facturas;
        }

        public static int getUltimoIdFacturaProveedor()
        {
            int ultimoId = getPersistencia().bringLastOID(new FacturaProveedor());
            return ultimoId;
        }

        private static List<FacturaProveedor> listarFacturasProvPorVencimiento(DateTime desde, DateTime hasta)
        {
            return null;
            //List<FacturaProveedor> facturas = new List<FacturaProveedor>();
            //FacturaProveedor facturaAux = new FacturaProveedor();
            //foreach (Documento unD in LDocumentos)
            //{
            //    if (unD.GetType().Equals(facturaAux.GetType()))
            //    {
            //        FacturaProveedor facturaProvAux = (FacturaProveedor)unD;
            //        if (facturaProvAux.Vencimiento >= desde && facturaProvAux.Vencimiento <= hasta)
            //        {
            //            if (facturaProvAux.Monto != 0)
            //            {
            //                facturas.Add(facturaProvAux);
            //            }
            //        }
            //    }
            //}
            //return facturas;
        }

        #endregion

        #region IVA

        public static void agregarIVA(string unNombre, int unPorcentaje)
        {
            IVA unIVA = new IVA();
            unIVA.Nombre = unNombre;
            unIVA.Porcentaje = unPorcentaje;
            unIVA.added();
        }

        public static void modificarIVA(string unNombre, int unPorcentaje, IVA unIVA)
        {            
            unIVA.Nombre = unNombre;
            unIVA.Porcentaje = unPorcentaje;
            unIVA.updated();
        }

        public static void eliminarIVA(IVA unIVA)
        {
            unIVA.removed();
        }

        public static List<IVA> getIVAs()
        {
            IVA IVAAux = new IVA();
            List<object> objectIVAs = getPersistencia().bringList(IVAAux);
            List<IVA> ivas = new List<IVA>();
            for (int i = 0; i < objectIVAs.Count; i++)
            {
                IVA unIVA = (IVA)objectIVAs[i];
                ivas.Add(unIVA);
            }
            return ivas;
        }

        public static int getUltimoIdIVA()
        {
            int ultimoId = getPersistencia().bringLastOID(new IVA());
            return ultimoId;
        }

        #endregion

        #region Medios de Pago

        public static void agregarMedioDePago(string unNombre)
        {
            MedioDePago unMedio = new MedioDePago();
            unMedio.Nombre = unNombre;            
            unMedio.added();
        }

        public static void modificarMedioDePago(string unNombre, MedioDePago unMedio)
        {
            unMedio.Nombre = unNombre;            
            unMedio.updated();
        }

        public static void eliminarMedioDePago(MedioDePago unMedio)
        {
            unMedio.removed();
        }

        public static List<MedioDePago> getMediosDePago()
        {
            MedioDePago medioAux = new MedioDePago();
            List<object> objectMediosDePago = getPersistencia().bringList(medioAux);
            List<MedioDePago> mediosDePago = new List<MedioDePago>();
            for (int i = 0; i < objectMediosDePago.Count; i++)
            {
                MedioDePago unMedio = (MedioDePago)objectMediosDePago[i];
                mediosDePago.Add(unMedio);
            }
            return mediosDePago;
        }

        public static int getUltimoIdMedioDePago()
        {
            int ultimoId = getPersistencia().bringLastOID(new MedioDePago());
            return ultimoId;
        }

        #endregion

        #region notasCredito

        public static void agregarNotaCredito(Cliente unCliente, List<Detalle> unaLDetalles, DateTime unaFecha,
            double unMonto)
        {
            NotaCredito unaNotaCred = new NotaCredito();
            unaNotaCred.Cliente = unCliente;
            unaNotaCred.Detalles = unaLDetalles;
            unaNotaCred.Fecha = unaFecha;
            unaNotaCred.Monto = unMonto;            
            unaNotaCred.added();
        }

        public static void modificarNotaCredito(Cliente unCliente, List<Detalle> unaLDetalles, DateTime unaFecha,
            double unMonto, NotaCredito unaNotaCredito)
        {
            unaNotaCredito.Cliente = unCliente;
            unaNotaCredito.Detalles = unaLDetalles;
            unaNotaCredito.Fecha = unaFecha;
            unaNotaCredito.Monto = unMonto;
            unaNotaCredito.updated();
        }

        public static List<NotaCredito> getNotasCredito()
        {
            NotaCredito notaAux = new NotaCredito();
            List<object> objectNotas = getPersistencia().bringList(notaAux);
            List<NotaCredito> notas = new List<NotaCredito>();
            for (int i = 0; i < objectNotas.Count; i++)
            {
                NotaCredito unaNota = (NotaCredito)objectNotas[i];
                notas.Add(unaNota);
            }
            return notas;
        }

        public static int getUltimoIdNotasCredito()
        {
            int ultimoId = getPersistencia().bringLastOID(new NotaCredito());
            return ultimoId;
        }

        public static NotaCredito buscarNotaCreditoPorId(int id)
        {
            return getPersistencia().buscarNotaCreditoPorId(id);
        }

        #endregion

        #region notasDebito

        public static void agregarNotaDebito(Cliente unCliente, string unaDescripcion, DateTime unaFecha, double unMonto)
        {
            NotaDebito unaNotaDebito = new NotaDebito();
            unaNotaDebito.cliente = unCliente;
            unaNotaDebito.Descripcion = unaDescripcion;
            unaNotaDebito.Fecha = unaFecha;
            unaNotaDebito.Monto = unMonto;            
            unaNotaDebito.added();
        }

        public static void modificarNotaDebito(Cliente unCliente, string unaDescripcion,
            DateTime unaFecha, double unMonto, NotaDebito unaNotaDebito)
        {
            unaNotaDebito.cliente = unCliente;
            unaNotaDebito.Descripcion = unaDescripcion;
            unaNotaDebito.Fecha = unaFecha;
            unaNotaDebito.Monto = unMonto;
            unaNotaDebito.updated();
        }

        public static List<NotaDebito> getNotasdebito()
        {
            NotaDebito notaAux = new NotaDebito();
            List<object> objectNotas = getPersistencia().bringList(notaAux);
            List<NotaDebito> notas = new List<NotaDebito>();
            for (int i = 0; i < objectNotas.Count; i++)
            {
                NotaDebito unaNota = (NotaDebito)objectNotas[i];
                notas.Add(unaNota);
            }
            return notas;
        }

        public static int getUltimoIdNotasDebito()
        {
            int ultimoId = getPersistencia().bringLastOID(new NotaDebito());
            return ultimoId;
        }

        public static NotaDebito buscarNotaDebitoPorId(int id)
        {
            return getPersistencia().buscarNotaDebitoPorId(id);
        }

        #endregion

        #region pagosProveedor

        public static void agregarPagoProveedor(DateTime unaFecha, double unMonto, int unNumerador, Proveedor unProveedor)
        {
            PagoProveedor unPago = new PagoProveedor();
            unPago.Fecha = unaFecha;
            unPago.Monto = unMonto;
            unPago.Numerador = unNumerador;
            unPago.Proveedor = unProveedor;            
            unPago.added();
        }

        public static void modificarPagoProveedor(DateTime unaFecha, double unMonto,
            int unNumerador, Proveedor unProveedor, PagoProveedor unPago)
        {
            unPago.Fecha = unaFecha;
            unPago.Monto = unMonto;
            unPago.Numerador = unNumerador;
            unPago.Proveedor = unProveedor;
            unPago.updated();
        }

        public static List<PagoProveedor> getPagosProveedor()
        {
            PagoProveedor pagoAux = new PagoProveedor();
            List<object> objectPagos = getPersistencia().bringList(pagoAux);
            List<PagoProveedor> pagos = new List<PagoProveedor>();
            for (int i = 0; i < objectPagos.Count; i++)
            {
                PagoProveedor unPago = (PagoProveedor)objectPagos[i];
                pagos.Add(unPago);
            }
            return pagos;
        }

        public static int getUltimoIdPagosProveedor()
        {
            int ultimoId = getPersistencia().bringLastOID(new PagoProveedor());
            return ultimoId;
        }

        #endregion

        #region planes de pago

        public static void agregarPlanDepago(int unaCantDias, string unNombre, int unDescuento)
        {
            PlanDePago unPlan = new PlanDePago();
            unPlan.CantDias = unaCantDias;
            unPlan.Descuento = unDescuento;
            unPlan.Nombre = unNombre;            
            unPlan.added();
        }

        public static void eliminarPlanDePago(PlanDePago unPlan)
        {            
            unPlan.removed();
        }

        public static void modificarPlanDePago(int unaCantDias, string unNombre, int unDescuento, PlanDePago unPlan)
        {
            unPlan.CantDias = unaCantDias;
            unPlan.Descuento = unDescuento;
            unPlan.Nombre = unNombre;
            unPlan.updated();
        }

        public static List<PlanDePago> getPlanesDePago()
        {
            PlanDePago planAux = new PlanDePago();
            List<object> objectPlanesDePago = getPersistencia().bringList(planAux);
            List<PlanDePago> planes = new List<PlanDePago>();
            for (int i = 0; i < objectPlanesDePago.Count; i++)
            {
                PlanDePago unPlan = (PlanDePago)objectPlanesDePago[i];
                planes.Add(unPlan);
            }
            return planes;
        }

        public static int getUltimoIdPlanesDePago()
        {
            int ultimoId = getPersistencia().bringLastOID(new PlanDePago());
            return ultimoId;
        }

        #endregion

        #region proveedores

        public static void agregarProveedor(string unaDireccion, string unEMail, int unFax,
            string unNombre, PlanDePago unPlanDePago, string unRUT)
        {
            Proveedor unProv = new Proveedor();
            unProv.RUT = unRUT;
            unProv.Direccion = unaDireccion;
            unProv.EMail = unEMail;
            unProv.Fax = unFax;
            unProv.Habilitado = true;
            unProv.Nombre = unNombre;
            unProv.PlanDePago = unPlanDePago;                      
            unProv.added();
        }

        public static void eliminarProveedor(Proveedor unProv)
        {            
            unProv.removed();
        }        

        public static void modificarProveedor(string unaDireccion, string unEMail, int unFax,
            string unNombre, PlanDePago unPlanDePago, string unRUT, bool esHabilitado, Proveedor unProveedor)
        {
            unProveedor.RUT = unRUT;
            unProveedor.Direccion = unaDireccion;
            unProveedor.EMail = unEMail;
            unProveedor.Fax = unFax;            
            unProveedor.Nombre = unNombre;
            unProveedor.PlanDePago = unPlanDePago;
            unProveedor.Habilitado = esHabilitado;
            unProveedor.updated();
        }

        public static List<Proveedor> getProveedores()
        {
            Proveedor proveedorAux = new Proveedor();
            List<object> objectproveedores = getPersistencia().bringList(proveedorAux);
            List<Proveedor> proveedores = new List<Proveedor>();
            for (int i = 0; i < objectproveedores.Count; i++)
            {
                Proveedor unProveedor = (Proveedor)objectproveedores[i];
                proveedores.Add(unProveedor);
            }
            return proveedores;
        }

        public static int getultimoIdProveedor()
        {
            int ultimoId = getPersistencia().bringLastOID(new Proveedor());
            return ultimoId;
        }

        public static List<Proveedor> buscarProveedores(string nombre, double saldoDesde, double saldoHasta,
           string rut, int numeroDesde, int numeroHasta, int idPlanDePago, string unaDireccion)
        {
            return getPersistencia().buscarProveedores(nombre, saldoDesde, saldoHasta, rut,
                numeroDesde, numeroHasta, idPlanDePago, unaDireccion);
        }

        public static List<Proveedor> traerProveedoresNoHabilitados()
        {
            return getPersistencia().traerProveedoresNoHabilitados();
        }

        //public static Proveedor buscarProveedorPorId(int id)
        //{
        //    return getPersistencia().buscarProveedorPorId(id);
        //}       

        #endregion

        #region recibos

        public static void agregarRecibo(Cliente unCliente, DateTime unaFecha, double unMonto)
        {
            Recibo unRecibo = new Recibo();
            unRecibo.Cliente = unCliente;
            unRecibo.Fecha = unaFecha;
            unRecibo.Monto = unMonto;            
            unRecibo.added();
        }

        public static void modificarRecibo(Cliente unCliente, DateTime unaFecha, double unMonto, Recibo unRecibo)
        {
            unRecibo.Cliente = unCliente;
            unRecibo.Fecha = unaFecha;
            unRecibo.Monto = unMonto;
            unRecibo.updated();
        }

        public static List<Recibo> getRecibos()
        {
            Recibo reciboAux = new Recibo();
            List<object> objectRecibos = getPersistencia().bringList(reciboAux);
            List<Recibo> recibos = new List<Recibo>();
            for (int i = 0; i < objectRecibos.Count; i++)
            {
                Recibo unRecibo = (Recibo)objectRecibos[i];
                recibos.Add(unRecibo);
            }
            return recibos;
        }

        public static int getUltimoIdRecibo()
        {
            int ultimoId = getPersistencia().bringLastOID(new Recibo());
            return ultimoId;
        }

        #endregion

        #region tiposDeDocumento

        public static List<TipoDocumento> getTiposDeDocumento()
        {
            TipoDocumento tipoAux = new TipoDocumento();
            List<object> objectTiposDeDocumento = getPersistencia().bringList(tipoAux);
            List<TipoDocumento> tiposDocumento = new List<TipoDocumento>();
            for (int i = 0; i < objectTiposDeDocumento.Count; i++)
            {
                TipoDocumento unTipoDocumento = (TipoDocumento)objectTiposDeDocumento[i];
                tiposDocumento.Add(unTipoDocumento);
            }
            return tiposDocumento;
        }

        #endregion

    }
}
